/**数据表格页面组件，View路径：module/component/views/GridView
 * <pre>
 * 初始化表格参数为：{config:{grid:{Config options参数},callback:{Event相关事件}}}。
 * 例如：new GridView({config:{grid:{colModel:[]},callback:{onSelect:function(e){}}}});
 * </pre>
 * @class ngc.component.view.GridView
 */


define(["module/component/views/CommonUIView"],function(CommonView) {

	var GridView = CommonView.extend({		
		getGrid : function() {
			return this.getComponentObject();
		},
		afterRender : function() {
			this.on("gridInitAfter",function(){
				
				this.setInitFlag(true);
				
			}.bind(this));
			
			this._initGrid();
			
			this.trigger("viewRenderAfter");
		},
		
		setSize:function(dela){
			this.$el.outerHeight(dela);
		},
		
		
		/**
		 * 初始化Grid对应的Model，执行此方法后，将为grid增加Model功能，相关数据操作可以直接对Grid进行操作
		 * @method modelInit
		 */
		modelInit:function(){
			var _gridConfig = this.getOptionConfig().grid;
			if(_gridConfig.colModel){
				
				var _defaults = {}, _kId;
				$.each(_gridConfig.colModel,function(i){
					_defaults[this.name] = this.defaultValue?this.defaultValue:'';
					if(this.key==true)
						_kId = this.name;
				});
				if(!_kId){
					ngc.error("表格启用Model模式必须在表格配置参数colModel中，指定一列key=true作为行ID");
					return;
				}
				var _grid_model = ngc.Model.extend({defaults:_defaults,idAttribute:_kId});
				
				var _grid_collection = ngc.Collection.extend({model:_grid_model});
				
				this.collection = new _grid_collection();
			}
			
		},
		
		/**
		 * 向Grid的model集合中添加数据，添加到集合的尾部
		 * @method pushData
		 * @param {Array} data 待添加的JSON数组
		 * @param {Object} options 触发操作选项
		 */
		pushData:function(data,options){
			if(this.collection){
				this.collection.push(data,options);
			}
		},
		
		
		/**
		 * 隐藏表格按钮栏按钮
		 * @method
		 * @param {String} [id] 按钮的ID,不传该参数表示隐藏整个按钮栏
		 */
		hideNavButton:function(id){
			if(!id){
				this.$('#tb_'+this.getComponentId()).children("div").hide();
			}else{
				this.$('#tb_'+this.getComponentId()).children("div").children("#"+id).hide();
			}
				
		},
		
		/**
		 * 隐藏表格按钮栏按钮
		 * @method
		 * @param {String} [id] 按钮的ID,不传该参数表示隐藏整个按钮栏
		 */
		showNavButton:function(id){
			if(!id){
				this.$('#tb_'+this.getComponentId()).children("div").show();
			}else{
				this.$('#tb_'+this.getComponentId()).children("div").show();
				this.$('#tb_'+this.getComponentId()).children("div").children("#"+id).show();
			}
				
		},
		
		/**
		 * 向Grid的model集合中添加数据
		 * @method add
		 * @param {Array} data 待添加的JSON数组
		 * @param {Object} option  触发操作选项
		 */
		add:function(data,option){
			if(this.collection){
				this.collection.push(data,option);
			}
		},
		
		
		/**
		 * 获取Collection
		 * @return {Object} Collection对象
		 */
		getCollection:function(){
			return this.collection;
		},
		
		
		/**
		 * 删除grid的model集合中指定id的记录
		 * @param {String} id 指定的ID
		 * @param {Object} option  触发操作选项
		 */
		removeData:function(id,option){
			if(this.collection){
				this.collection.remove(id,option);
			}
		},
		
		
		/**
		 * 获取grid的model集合中指定id的记录
		 * @param {String} id 指定的ID
		 */
		get:function(id){
			if(this.collection){
				return this.collection.get(id);
			}
		},
		
		/**
		 * 修改Grid集合中某个值
		 * @method set
		 * @param {Object} data 需要修改的数据
		 * @param {Object} option  触发操作选项
		 */
		set:function(data,option){
			if(this.collection){
				this.collection.set(data,option);
			}
		},
		/**
		 * 重新设置集合
		 * @method reset
		 * @param {Array} data 需要添加的数据
		 * @param {Object} option  触发操作选项
		 */
		reset:function(data,option){
			if(this.collection){
				this.collection.reset(data,option);
			}
		},
		
		/**
         * 编辑单元格
         * @param  {Number} irow 行索引
         * @param  {Number} icol 列索引
         * @param  {Boolean} [ed]   已在编辑状态的单元格是否不再触发编辑操作
         */
        editCell: function (irow, icol, ed) {
        	this.getGrid().grid('editCell',irow, icol, ed);
        },
		
		/**
         * 新增一行记录
         * @param  {Object} [option] 新增行的参数对象
         * option.rowid 行id
         * option.initdata 新增的初始化值
         * option.position 新增的行记录位置，默认last
         * option.useDefValues 是否用colmod内定义的默认值,默认true
         * option.addRowParam 额外的参数,保存或者取消的时候能取到;内置'oper=add',用来区分修改的行为
         */
		addRow:function(option){
			this.getGrid().grid('addRow',option);
		},
		
		
		 /**
         * 保存某行记录
         * @method saveRow
         * @param  {String} rowid              行id
         * @param  {Object} [option]           参数对象
         * option.aftersavefunc 数据保存成功后触发的函数
         * option.oper 可以区分是新增还是修改的操作行为
         * @returns {boolean} 是否保存成功
         */
        saveRow: function (rowid, o) {
        	return this.getGrid().grid('saveRow',rowid, o);
        },
        /**
         * 编辑某行记录
         * @method editRow
         * @param  {String} rowid    行id
         * @param  {Object} [option] 参数对象,内置'oper=edit'用来区分操作行为
         */
        editRow: function (rowid, o) {
        	this.getGrid().grid('editRow',rowid, o);
        },
		/**
         * @method reloadData 刷新数据源
         * @param {Array} data 需要增加的节点数据 JSON 对象集合
         * @return {Array} 返回Tree最终的节点数据集合
         */
		reloadData : function(data) {
			this.getGrid().grid('reloadData',data);
		},
		 /**
         * 新增数据，可以指定新增的位置
         * @param {String|Object} rowid 行id,此参数也可以是行数据,会自动取数据的key值作为rowid;
         * @param {Object} [rdata] 行数据,也可以是数据数组
         * @param {String} [pos]   数据新增的位置，默认是last，可选值有first、last，after和before则需要参考src参数
         * @param {String} [src]   新增位置的参考id
         * @return {Boolean} 是否新增成功
         */
		addRowData:function(rowid, rdata, pos, src){
			this.getGrid().grid('addRowData',rowid, rdata, pos, src);
		},
		 /**
         * 清空数据
         * @method clearData
         * @param  {Boolean} [clearfooter = false] 如果设置为true的话,footerrow的数据也会清空掉
         */
		clearData:function(opr){
			this.getGrid().grid('clearData',opr);
		},
        /**
         * 保存单元格
         * @param  {Number} irow 行索引
         * @param  {Number} icol 列索引
         */
        saveCell: function (irow, icol) {
        	this.getGrid().grid('saveCell',irow, icol);
        },
        /**
         * 取消单元格编辑
         * @param  {Number} irow 行索引
         * @param  {Number} icol 列索引
         */
        restoreCell: function (irow, icol) {
        	this.getGrid().grid('restoreCell',irow, icol);
        },
        /**
         * 在含有footerrow的场景下，可以获取或设置底部的值
         * @param  {String} action set or get
         * @param  {Object} data   如果是set方式,则此参数就是设置进去的值
         */
        footerData: function(action, data, format) {
        	this.getGrid().grid('footerData',irow, action, data, format);
        },
		 /**
         * 修改单元格内容及样式
         * @param {String} rowid   行id
         * @param {String} colname 列名,也可以是列的索引
         * @param {String} newData   单元格修改后的值,只修改样式的情况下只传""即可
         * @param {String} [prop]  修改后的单元格样式，可以是class也可以是css对象
         * @param {Object} [attrp] 修改后的单元格的附加属性，譬如可以修改title属性
         * @param {Boolean} [forceupd] 强制刷新id，如果单元格要修改成空值的，需要设置此参数为true;此参数主要用来区别只修改单元格样式功能用的
         */
		setCell:function( rowid, colname, newData, prop, attrp, forceupd){
			this.getGrid().grid('setCell',rowid, colname, newData, prop, attrp, forceupd);
		},
		 /**
         * 删除某行记录
         * @method delRow
         * @param  {String} rowid      行id
         * @param  {Object} [option]  参数对象,内置'oper=del'用来区分操作行为
         */
		delRow:function( rowid, option ){
			this.getGrid().grid('delRow', rowid, option );
		},
		/**
	     * 启用控件。
	     * @method
	     */
		enable:function( ){
			this.getGrid().grid('enable');
		},
		/**
	     * 禁用控件。
	     * @method
	     */
		disable:function( ){
			this.getGrid().grid('disable');
		},
		
	     /**
         * 获取单元格内容
         * @param {String} rowid   行id
         * @param {String} colname 列名,也可以是列的索引
         * @return {String}  获取单元格的值
         */
		getCell:function( rowid, colname ) {
			return this.getGrid().grid('getCell', rowid, colname );
		},
		
	    /**
         * 获取参数数据.目前等效于option方法
         * 此方法非常有用，可以获取很多需要的东西,如page当前页,rowNum每页记录数,records记录总数等等
         * <pre>
         *        var dataLength = grid.getGridParam("records记录总数等等");
         * </pre>
         * @param  {String} pName 参数的key值
         * @return {Object}       返回参数key值对应的值value
         */
		getGridParam:function( pName ) {
			return this.getGrid().grid('getGridParam',pName);
		},
		
		/**
		 * 根据列名获取某一列的所有值
		 * @param {String|Number} col 要获取的列名称或者列索引
		 * @return 要获取的列值数组，按照顺序
		 */
		getCellValuesByColumn:function(col){
			var _rst = [],that = this;
			if(!isNaN(col)){
				var col = this.getColumnIndexByName(col);
			}
			
			var datas = this.getRowData();
			
			$.each(datas,function(){
				_rst.push(this[col]?this[col]:"");
			})
			
			return _rst;
		},
		
		/**
		 * 获取表格ID数值的最大值
		 * @return {Number} 返回的当前最大ID
		 */
		getMaxId:function(){
			var ids = this.getDataIDs(),_rst = 0;
			$.each(ids,function(){				
				var _t = parseInt(this,0);
				_rst = _rst>_t?_rst:_t;
			})
			return _rst;
		},
		
		 /**
         * 获取界面的行元素
         * @param  {String} rowid 行id
         * @return {Object} 返回行id对应的dom节点
         */
		getGridRowById:function( rowid ) {
			return this.getGrid().grid('getGridRowById',rowid);
		},
        /**
         * 获取界面的行在表格中的索引
         * @param  {String} rowid 行id
         * @param  {Boolean} flag  默认false,设置为true则等效于与getGridRowById方法
         * @return {Object} 返回行在表格内的索引
         */
		getRowIndex:function( rowid, flag ){
			return this.getGrid().grid('getInd',rowid, flag );
		},
		 /**
         * 获取参考目标记录的前一条记录
         * @param  {String|Object} selection    参考目标记录的rowid;也可以是行数据对象
         */
		getPrevSelection:function( selection ){
			return this.getGrid().grid('getPrevSelection', selection );
		},
		/**
		 * 获取参考目标记录的后一条记录
		 * @param  {String|Object} selection    参考目标记录的rowid;也可以是行数据对象
		 */
		getNextSelection:function( selection ){
			return this.getGrid().grid('getNextSelection', selection );
		},
        /**
         * 获取表格单个或者全部数据(如果是分页则返回是本页的全部数据)
         * @param  {String} rowid (optional) 表格行记录的id
         * @param  {Boolean} usedata (optional) 是否从数据源中获取数据,默认true
         * @return {Object} 如果参数rowid为空，返回整个记录数组，否则只返回rowid对应的那条记录数据
         */
		getRowData:function( rowid, usedata ) {
			return this.getGrid().grid('getRowData',rowid, usedata);
		},
		/**
         * 修改行数据,目前不接受rowid值的修改
         * @param {String|Object} rowid 行id,或者是修改后的行数据
         * @param {Object} [data]  修改后的内容。如果第一个参数是修改后的行数据，则此参数可以省略或者传修改后的行样式
         * @param {String|Object} [cssp]  修改后的行样式，可以是class，也可以是css对象。如果第一个参数是修改后的行数据，则此参数省略不填
         * @return {Boolean} 是否修改成功
         */
		setRowData:function(rowid, data, cssp) {
			return this.getGrid().grid('setRowData',rowid, data, cssp);
		},
		/**
         * @method  获取选中行记录
         * @return {Object} 返回选中行的记录
         */
		getSelection:function(){
			return this.getGrid().grid('getSelection');
		},
		  /**
         * @method  设置行选中
         * @param {String|Object} selection 行id;也可以是行数据对象
         * @param {Boolean} onsr 是否触发行选中的事件onSelectRow
         */
		setSelection:function(selection,onsr){
			this.getGrid().grid('setSelection',selection,onsr);
		},
		/**
         * @method  取消行选中,还原编辑前的状态
         */
        resetSelection: function() {
        	this.getGrid().grid('resetSelection');
        },
        /**
         * @method row下移,treeGrid是在兄弟节点之间下移
         * @param {String} rowid   行id
         */
		moveRowDown:function( rowid ){
			this.getGrid().grid('moveDownRow',rowid);
		},
		 /**
         * @method 移动row
         * @param {String} rowid   待移动row的行id
         * @param {Number} offset 相对于当前待移动row的偏移量，往上为负整数，往下为正整数
         * @return
         */
		moveRow:function( rowid , offset ){
			this.getGrid().grid('moveRow',rowid, offset );
		},
		/**
         * row上移,treeGrid是在兄弟节点之间上移
         * @param {String} rowid   行id
         */
		moveRowUp:function( rowid ){
			this.getGrid().grid('moveUpRow',rowid);
		},
        /**
         * 给表格新增按钮
         * @method navButtonAdd
         * @param {Object} [option]
         *     option.id  按钮的id
         *     option.cssprop 按钮附加的样式,可以是css对象,也可以是class类选择器名称
         *     option.caption = newButton 按钮显示的名称
         *     option.title 鼠标移到按钮上的提示
         *     option.buttonicon = '' 按钮图标,为空则不使用图标;可以是ui-icon ui-icon-newwin;也可以是glyphicon glyphicon-plus
         *     option.onClick 按钮点击事件
         *     option.navpos  按钮在表格中新增的位置,默认'pager',可选'topbar','bottombar',也可以是任意selector;譬如设置为'topbar',则表示将按钮添加到topbar, 此处navpos参数为空的情况会取表格的初始化属性navpos,如果还取不到则默认定位到分页栏左侧
         *     ps:按钮失效加上ui-state-disabled样式即可;默认按钮排序是左对齐,可自行设置样式控制
         */
		navButtonAdd:function(option){
			return this.getGrid().grid('navButtonAdd',option);
		},
		 /**
         * @method 修改表格高度
         * @param {Number} nh 表格新的高度，可以带单位
         */
		setGridHeight:function(nh){
			return this.getGrid().grid('setGridHeight',nh);
		},
	    /**
         * 修改表格宽度
         * @param {Number} newWidth 新的宽度，不带单位，默认px
         * @param {Boolean} shrink 默认取初始化参数shrinkToFit的值，值为false的话，列宽不按比例缩小
         */
        setGridWidth: function(nwidth, shrink) {
        	this.getGrid().grid('setGridWidth',nwidth, shrink);
        },
        navButtonRefresh: function() {
        	this.getGrid().grid('navButtonRefresh');
        },
        /**
         * 如果改变了排序列及排序方式,可以通过此方法将界面显示的数据进行排序
         * @method sortGrid
         * @param {String} colname 需要排序的列名
         * @param {String} sortorder 排序的方式,升序asc还是降序desc
         */
		sortGrid:function( colname, sortorder ){
			this.getGrid().grid('sortGrid',colname, sortorder);
		},
	       /**
         * 设置表格是否可见
         * @method setGridState
         * @param {String} state 如果是hidden,则隐藏表格;如果是visible,则显示出表格
         */
        setGridState: function (state) {
        	this.getGrid().grid('setGridState',state);
        },
        /**
         * 设置参数数据.可以动态的改变表格的部分行为,部分涉及到ui变化的还需要调用专有的方法,譬如width变化要调用setGridWidth等
         * @param {Object} newParams 新的键值对，会覆盖原有的参数数据
         */
        setGridParam: function(newParams) {
        	this.getGrid().grid('setGridState',newParams);
        },
        /**
         * 设置复杂表头
         * @method setGroupHeaders
         * @param {Object} o 复杂表头的参数.
         * 参数内useColSpanStyle表示列头是否纵向合并单元格;
         * 参数内groupHeaders表示列头属性,内部startColumnName表示开始的列,numberOfColumns表示从开始列的数量,titleText表示合并后的列头显示值
         * <pre>
         * grid.setGroupHeaders({
         *    useColSpanStyle: true,
         *    groupHeaders:[{startColumnName: "amount", numberOfColumns: 3, titleText: "<em>Price</em>"}]
         * });
         * </pre>
         */
        setGroupHeaders: function (o) {
        	this.getGrid().grid('setGroupHeaders',o);
        },
        /**
         * 取消设置复杂表头,与setGroupHeaders相对
         */
        destroyGroupHeader: function () {
        	this.getGrid().grid('destroyGroupHeader');
        },
        /**
         * 设置列的冻结效果,在有水平滚动条的情况下,移动水平滚动条,此列位置不变.列的冻结从最左侧开始算起,可支持多列
         * @param {number} colnum 冻结列的数量
         */
        setFrozenColumns: function (colnum) {
        	this.getGrid().grid('setFrozenColumns',colnum);
        },
        /**
         * 取消列的冻结效果,与setFrozenColumns相对
         * @method destroyFrozenColumns
         */
        destroyFrozenColumns: function () {
        	this.getGrid().grid('destroyFrozenColumns');
        },
        /**
         * 可以在表格内拖动列,改变列的位置,依赖jqueryui的sortable事件;内部用,option中含有sortable:true时;tblrow 列头
         * @method sortableColumns
         * @param {String} tblrow
         */
        sortableColumns: function (tblrow) {
        	this.getGrid().grid('sortableColumns',tblrow);
        },

        /**
         * 隐藏(多)列
         * @param  {Array} colname 要隐藏的列名称的集合,也可以是单独一列的列名
         */
		hideCol:function( colname ){
			this.getGrid().grid('hideCol',colname);
		},
        /**
         * 显示(多)列
         * @param  {Array} colname 要显示的列名称的集合,也可以是单独一列的列名
         */
		showCol:function( colname ){
			this.getGrid().grid('showCol',colname);
		},
		 /**
         * 获取列的属性
         * @param  {String} colname 列定义的name
         * @return {Object}         列对象
         */
        getColProp: function (colname) {
        	return this.getGrid().grid('getColProp',colname);
        },
        /**
         * 设置列的属性
         * @param {String} colname 列定义的name
         * @param {Object} obj     列的新对象
         * @param {Boolean} [deep=true] 是不是深层赋值
         */
        setColProp: function (colname, obj, deep) {
        	this.getGrid().grid('setColProp',colname, obj, deep);
        },
        /**
         * @method groupingGroupBy
         * @param  {String} name    分组列名字
         * @param  {Object} options
         */
        groupingGroupBy: function(name, options) {
        	this.getGrid().grid('groupingGroupBy',name, options);
        },
        /**
         * @method groupingRemove
         * @param  {Boolean} current 是否取消分组
         */
        groupingRemove: function(current) {
        	this.getGrid().grid('groupingRemove',current);
        },
		//
		//~~~~~~扩展方法区
		//
		/**
         * 获取选中行ID
         * @return {String} 返回选中行Id
         */
		getSelectRowId:function(){
			return this.getGridParam("selrow");
		},
		/**
         * 获取checbox选中行ID
         * @return {Array} 返回选中行Id数组
         */
		getCheckRowsId:function(){
			return this.getGridParam("selarrrow"); 
		},
        /**
         * 获取多选模式下选中的记录
         * @return {Array} 打勾的记录
         */
		getCheckRows:function(){
			return this.getGrid().grid("getCheckRows");		
		},
		 /**
         * 获取修改过的单元格记录,可用于一次性提交
         * @param  {String} [mthd] 可设置为值dirty，设置的话则返回修改过的单元格记录,为空则返回修改过的行记录
         */
		getChangedCells:function(){
			return this.getGrid().grid("getChangedCells");		
		},
	       /**
         * 获取所有行的id
         * @return {Array} 返回rowid的集合
         */
        getDataIDs: function() {
        	return this.getGrid().grid("getDataIDs");		
        },		
		/**
		 * 删除选中行
		 * @return {String} 删除的选中行ID
		 */
		delSelectRow:function(){
			var _sId = this.getSelectRowId();
			this.delRow(_sId);
			return _sId;
		},
		/**
		 * 删除多选框选中行
		 * @return {Array} 删除的选中行ID数组
		 */
		delCheckRows:function(){
			var keys = this.getCheckRowsId();
			if(keys){
				$.each(keys,function(){
					this.delRow(this);
				}.bind(this))
			}
			return keys;
		},
        /**
         * 实现多选模式下表格的全选,清空
         * @param {Boolean} [f] true表示全选,false表示清空
         */
		setAllCheckRows:function(f){
			this.getGrid().grid("setAllCheckRows", f);		
			return this;
		},
		
	    /**
         * 禁用,启用多个复选框
         * @param {Array} rowIds 选中行的id集合
         * @param {Boolean} flag true表示禁用,false表示取消禁用
         */
		setCheckDisabled:function( rowIds, flag ){
			this.getGrid().grid("setCheckDisabled", rowIds, flag);	
		},
        /**
         * 设置，取消，反选多选记录
         * @param {Array} rowIds 选中行的id集合
         * @param {Boolean} flag 为空默认反选,true表示全选,false表示清空
         */
		setCheckRows:function( rowIds, flag ){
			this.getGrid().grid("setCheckRows", rowIds, flag);	
		},
	    /**
         * 禁用,启用全部复选框
         * @param {Boolean} flag true表示禁用复选框功能，false表示取消禁用复选框功能
         */
		setAllCheckDisabled:function(f){
			this.getGrid().grid("setAllCheckDisabled", f);			
		},
		
		//~~~~~~~~~~~
		
        /**
         * 新增一个或多个tree节点
         * @param {Array} dataArr  一个或多个tree节点数据，这些节点数据既可以是线性结构，也可以是带有children节点的层级结构。
         * @param {Object|String} [parent]  父节点行数据,也可以是父节点rowid,为空则表示数据加在根节点上
         * @param {Boolean} [expandData] 如果新增的数据所在的父节点未展开且此值设置为true，则触发展开操作
         * <pre>
         *     grid.addChildNodes([{id: 1, name: "test1", childern: [
         *                                        {id: 1-1, name: "test1-1"}, {id: 1-2, name: "test1-2"}]},
         *                                        {id: 2, name: "test2"}], parentid);
         * </pre>
         * <pre>
         *     grid.addChildNodes([{id: 1, name: "test1"},
         *                                        {id: 2, name: "test2"},
         *                                        {id: 3, name: "test3"}], parentid);
         * </pre>
         * <pre>
         *      grid.addChildNodes([{id: 1, name: "test1"}], parentid);
         * </pre>
         */
        addChildNodes: function (dataArr, parent, expandData) {
        	this.getGrid().grid("addChildNodes", dataArr, parent, expandData);	
        },
   
	    /**
	     * 节点是否可见，可用于定位某个节点用
	     * @param  {Object} rowData 节点数据
	     * @return {Boolean}    节点是否可见，所有的父节点都是展开状态节点才是可见状态
	     */
	    isVisibleNode: function (rowData) { 
	    	return this.getGrid().grid("isVisibleNode", rowData);	
	    },
        /**
         * 修改节点数据
         * @method modifyTreeNode
         * @param {String|Object} rowid 行id,也可以直接传入行数据rowData
         * @param {Object} [rowData]  行数据,行标识的值目前不支持修改
         */
        modifyTreeNode: function (rowid, data) {
        	this.getGrid().grid("modTreeNode", dataArr, parent, expandData);	
        },
        /**
         * 删除tree节点
         * @param  {String|Object} rowid 行id,也可以是行数据rowData
         */
        delTreeNode: function (rowid) {
        	this.getGrid().grid("modTreeNode", rowid);
        },
        /**
         * 展开节点数据
         * @param  {Object} rc 节点数据
         * @param  {Boolean} flag 是否触发rowExpand事件
         */
        expandNode: function (rc, flag) {
        	this.getGrid().grid("expandNode", rc, flag);
        },
        /**
         * 收缩节点数据
         * @param  {Object} rc 节点数据
         * @param  {Boolean} flag 是否触发rowCollapse事件
         */
        collapseNode: function (rc, flag) {
        	this.getGrid().grid("collapseNode", rc, flag);
        },
        /**
         * 获取同级的前一个节点
         * @param  {Object} rc 当前节点数据
         * @return {Object} 前一个节点数据
         */
        getPrevNode: function (rc) {
        	return this.getGrid().grid("getPrevNode", rc);
        },
        /**
         * 获取同级的后一个节点
         * @param  {Object} rc 当前节点数据
         * @return {Object} 后一个节点数据
         */
        getNextNode: function (rc) {
        	return this.getGrid().grid("getNextNode", rc);
        },
        /**
         * 获取跟节点数据
         * @return {Array} 根节点数据集合
         */
        getRootNodes: function () {
        	return this.getGrid().grid("getRootNodes");
        },
        /**
         * 获取某节点的级别，即相对于根节点的level
         * @param  {Object} rowData 节点数据
         * @return {Object} 所在tree里面的级别
         */
        getNodeDepth: function (rowData) {
        	return this.getGrid().grid("getNodeDepth",rowData);
        },
        /**
         * 获取某节点的父节点数据
         * @param  {Object} rowData 节点数据
         * @return {Object} 父节点数据
         */
        getNodeParent: function (rowData) {
        	return this.getGrid().grid("getNodeParent",rowData);
        },
        /**
         * 获取某节点的子节点数据
         * @param  {Object} rowData 节点数据
         * @return {Array} 下一级子节点数据集合
         */
        getNodeChildren: function (rowData) {
        	return this.getGrid().grid("getNodeChildren",rowData);
        },
        /**
         * 获取某节点下的全部节点数据，含自身数据
         * @param {Object} rowData 节点数据
         * @param {Boolean} [flat=true] 获取的数据集合是否平铺。为true，全部数据存入数组中返回；为false，则子节点的数据位于父节点的children属性中
         * @return {Array | Object}  flat为true，则数据集合以数组形式返回；为false，则只返回该节点数据
         */
        getFullTreeNode: function (rowData, flat) {
        	return this.getGrid().grid("getFullTreeNode",rowData,flat);
        },
        /**
         * 新增一个或多个tree节点
         * @param {Array} dataArr  一个或多个tree节点，这些节点只能是线性结构。如果节点中包含children节点，则需使用addChildNodes方法
         * @param {Object|String} [parent]  父节点行数据,也可以是父节点rowid,为空则表示数据加在根节点上
         * @param {Boolean} [expandData] 如果新增的数据所在的父节点未展开且此值设置为true，则触发展开操作
         * @param {String} [pos]   数据新增的位置，默认是last，可选值有first、last，after和before则需要参考src参数
         * @param {String} [src]   新增位置的参考标识
         * <pre>
         *      grid.addTreeNodes([{id: 1, name: "test1"},
         *                                        {id: 2, name: "test2"},
         *                                        {id: 3, name: "test3"}], parentid);
         * </pre>
         * <pre>
         *      grid.addTreeNodes([{id: 1, name: "test1"}], parentid);
         * </pre>
         */
        addTreeNodes: function (dataArr, parentid, expandData, pos, src){
        	this.getGrid().grid("addTreeNodes", dataArr, parent, expandData, pos, src);	
        },
        /**
         * 获取同级的所有节点数据
         * @param {Object} rowData 当前节点数据
         * @return {Array} 同级的所有节点数据集合
         */
        getSiblingNodes: function (rowData) {
        	return this.getGrid().grid("addTreeNodes",rowData);
        },
        /**
         * 给表格加上可拖拽改变,依赖jqueryui的resizable控件,能改变表格大小
         * @param  {Object} [opts] 可定义_stop_事件，会在拖拽结束的时候执行
         */
        gridResize: function (opts) {
        	this.getGrid().grid("gridResize",opts)
        },
        
        /**
    	 * 调用resize处理
    	 * @param {Boolean} [force=false] 强制调用resize处理，默认false，只有当宽度和高度变化才执行
    	 */
        resize: function (force) {
        	this.getGrid().grid("resize",force)
        },
        /**
         * 可在表格间拖拽数据,依赖jqueryui的拖拽事件,不支持tree操作
         * @param  {Object} opts 可定义onstart、onstop事件，会在拖拽开始、结束的时候执行等等,
         * opts.connectWith 此值不为空,表示拖拽的目标对象.如示例中gridDrag2的行数据能拖进gridDrag中
         * <pre>
         *  this.gridDnD({connectWith:"#gridDrag"})
         * </pre>
         */
        gridDnD: function (opts) {
        	this.getGrid().grid("gridDnD",opts)
        },
        /**
         * 可以在表格内拖动行数据移动位置,依赖jqueryui的拖拽事件,不支持tree操作
         * @param  {Object} [opts] 可定义start和update事件，会在拖拽开始和结束的时候执行
         */
        sortableRows: function (opts) {
        	this.getGrid().grid("sortableRows",opts);
        },
        /**
         * @private
         * 树表格排序
         * @param {String} sortname  排序列name
         * @param {String} newDir    排序方式        升序/降序
         * @param {String} st        排序列数据类型  date/number/int/float...
         * @param {String} datefmt   日期格式        如果排序列是日期的话，按照此格式parse日期
         */
        sortTree: function(sortname, newDir, st, datefmt) {
        	this.getGrid().grid("sortname",newDir, st, datefmt);
        },
        
        //~~~~~~~~~~subgrid~~~~~
        /**
         * 设置SubGrid的宽度（正常情形下不需要调用）
         * @param {Number} parentGridWidth 父Grid宽度
         */
        setSubGridWidth: function (parentGridWidth) {
        	this.getGrid().grid("setSubGridWidth",parentGridWidth);
        },
        /**
         * 获取指定rowId的$subGrid(包括显示和隐藏的,不包括未生成的）则返回$subGrid(jquery对象)，否则为null
         * @param {String} rowId 行ID
         * @returns 如果有subGrid（包括显示和隐藏的）则返回$subGrid(jquery对象)，否则为null
         */
        getSubGrid: function (rowId) {
        	return this.getGrid().grid("getSubGrid",rowId);
        },
        
        /**
         *展开SubGrid
         * @param {String} rowId 行Id
         */
        expandSubGridRow: function (rowId) {
        	this.getGrid().grid("expandSubGridRow",rowId);
        },
        
        /**
         * 展开所有SubGrid
         */
        expandAllSubGridRow: function () {
        	this.getGrid().grid("expandAllSubGridRow");
        },
        
        /**
         * 收起所有SubGrid
         */
        collapseAllSubGridRow: function () {
        	this.getGrid().grid("collapseAllSubGridRow");
        },
        
        
        
        /**
         * 收缩SubGrid
         * @param {String} rowId 行Id
         */
        collapseSubGridRow: function (rowId) {
        	this.getGrid().grid("collapseSubGridRow",rowId);
        },
        
        /**
         * 如果rowId下的SubGrid展开则收起，否则展开
         * @param {String} rowId 行Id
         */
        toggleSubGridRow: function (rowId) {
        	this.getGrid().grid("toggleSubGridRow",rowId);
        },
		
		/**
		 * @private 
		 * @method 初始化表格
		 */
		_initGrid : function() {
			if(this.getOptionConfig()&&this.getOptionConfig().grid){
				var _data = [],that = this;
				if(ngc.isFunction(this.getOptionConfig().grid.data)){
					_data = this.getOptionConfig().grid.data
					.call(this,
							this.getOptionConfig());
				}else{
					if(this.getOptionConfig().grid.data){
						_data = this.getOptionConfig().grid.data;
					}
				}
				this.getOptionConfig().grid.data = _data;
				
				this.getOptionConfig().grid.onRightClickRow = function(event, rowid){
					this.setSelection(rowid);
				}.bind(this);
				
				var _eventBind = {};
				
				//handler user defined content
				$.each(this.getOptionConfig().grid.colModel,function(k){
					var formatter = this.formatter;
					var _c = that._enhanceFormatterType(this);	
					if(_c._formatter_ui_id){
						if(!_eventBind[formatter]){
							_eventBind[formatter] = [];
						}
						
						_eventBind[formatter].push(_c);
					}
					if(this.edittype=='autocomplete'){
						delete this.edittype;
						this.autocomplete = 'autocomplete';
					}
				});
				
				var $grid = this.getGrid().grid(this.getOptionConfig().grid);
				
				if(this.getOptionConfig().callback){
					var that = this;
					$.each(this.getOptionConfig().callback,function(k){
						var _fn = k;
						$grid.on("grid:"+k.toLowerCase(),function(){
							if(ngc.isFunction(that.getOptionConfig().callback[_fn]))
								return that.getOptionConfig().callback[_fn].apply(that,arguments);
						});
						if(k=='reloadGrid'){
							that.getGrid().grid("instance").element.on("reloadGrid",function(){
								if(ngc.isFunction(that.getOptionConfig().callback[_fn]))
									return that.getOptionConfig().callback[_fn].apply(that,arguments);
							});
						}
					});
				}
								
				//处理自定义组件事件
				if(_eventBind){
					$.each(_eventBind,function(k){
						var _m = k,_t = this;
						$.each(_t,function(i){
							that._bindEnhanceFormatterTypeEvent(_m,this);
						});																	
					});
				}
				
				this._enhanceCellTypeEvent();
				
				this.trigger("gridInitAfter");
			}				
		},
		
		/**
		 * 获取Grid已经保存的列配置信息
		 * @param {String|Number} col 列索引或者列ID
		 * @return {Object} 
		 */
		getGridColModel:function(col){
			var _opt = {};
			$.each(this.getGrid().grid("instance").p.colModel,function(i){
				if(this.name===col||i===col){
					_opt = this;
					return false;
				}
			})
			return _opt;
		},
		
		/**
		 * 初始化表格中下拉框的值，重新进行初始化操作
		 * @method initCellDropItem
		 * @param {String} rowid 行ID
		 * @param {String|Number} col 列索引号或列的name
		 * @param {Array} datas 需要初始化的下拉框键值对
		 */
		initCellDropItem:function(rowid,col,datas){
			
			var _os = this._getCellObject(rowid,col).find('select');
			
			var _opt = {};
			
			$.each(this.getGrid().grid("instance").p.colModel,function(i){
				if(this.name===col||i===col){
					_opt = this;
					return false;
				}
			})
			
			if(_os.length>0){
				_os.empty();
				var oSv = datas.value, key, _olv = this.getCell(rowid, _opt.name);												
                for (key in oSv) {
                    if (oSv.hasOwnProperty(key) ){
                        ov = document.createElement("option");
                        ov.setAttribute("role","option");
                        ov.value = key; ov.innerHTML = oSv[key];	
                        if(_olv&&_olv==key) {ov.selected ="selected";}
                        _os.append($(ov));					                                  
                    }
                    
                    
                }
                _opt._opt_temp_value = _opt.editoptions;
                _opt.editoptions = datas;
			}		
		},
		
		_enhanceCellTypeEvent:function(){
			var that = this;
			$.each(this.getOptionConfig().grid.colModel,function(k){
				var _cfg = this;
				if(this.edittype&&ngc.isFunction(this.afterChange)){
					that.getGrid().on('grid:aftereditrow',function(e, rowid, data, option){
						var cfg = _cfg;
						var tcell = that._getCellObject(rowid,_cfg.name);
						
						if(cfg.edittype&&ngc.isFunction(cfg.afterChange)&&tcell.children()){
							tcell.children().change(/*bind('input propertychange', */function() {  
								
								var _c = tcell, _olv = that.getCell(cfg.name);
								_cfg.afterChange.call(that,
										{initDropItem:function(col,datas){
											var _os = that._getCellObject(rowid,col).find('select');
											
											var _opt = {};
											
											$.each(that.getGrid().grid("instance").p.colModel,function(i){
												if(this.name===col||i===col){
													_opt = this;
													return false;
												}
											})
											
											if(_os.length>0){
												_os.empty();
												var oSv = datas.value, key;												
					                            for (key in oSv) {
					                                if (oSv.hasOwnProperty(key) ){
					                                    ov = document.createElement("option");
					                                    ov.setAttribute("role","option");
					                                    ov.value = key; ov.innerHTML = oSv[key];	
					                                    if(_olv&&_olv==key) {ov.selected ="selected";}
					                                    _os.append($(ov));					                                  
					                                }
					                                
					                                
					                            }
					                            _opt._opt_temp_value = _opt.editoptions;
					                            _opt.editoptions = datas;
											}									
										},
										rowId:rowid
										},tcell.children().val());
							});
						}
						
						
					});
					
					that.getGrid().on('grid:beforerestorerow',function(e, rowid, data, option){
						var cfg = _cfg;
						if(cfg.edittype&&ngc.isFunction(cfg.afterChange)){
							$.each(that.getGrid().grid("instance").p.colModel,function(i){
								if(this._opt_temp_value){
									var _os = that._getCellObject(rowid,i).find('select');
									var oSv = this._opt_temp_value.value, key, _olv = that.getCell(this.name);												
		                            for (key in oSv) {
		                                if (oSv.hasOwnProperty(key) ){
		                                    ov = document.createElement("option");
		                                    ov.setAttribute("role","option");
		                                    ov.value = key; ov.innerHTML = oSv[key];	
		                                    if(_olv&&_olv==key) {ov.selected ="selected";}
		                                    _os.append($(ov));	
		                                   
		                                }
		                            }
		                            _opt.editoptions = _opt._opt_temp_value;								
								}
							})
						}
						
					});
					/*that.getGrid().on('grid:beforesaverow',function(e, rowid, data, option){
						
						 $.each(that.getGrid().grid("instance").p.colModel,function(i){
								if(this._opt_temp_value){
									this.editoptions = this._opt_temp_value;
								}
						})
					})*/
					

					that.getGrid().on('grid:aftereditcell',function(e, rowid, data, option){
						var cfg = _cfg;
						var tcell = that._getCellObject(rowid,_cfg.name);
						
						if(cfg.edittype&&ngc.isFunction(cfg.afterChange)&&tcell.children()){
							tcell.children().change(/*.bind('input propertychange', */function() {  
								
								var _c = tcell, _olv = that.getCell(cfg.name);
								_cfg.afterChange.call(that,
										{initDropItem:function(col,datas){
											var _os = that._getCellObject(rowid,col).find('select');
											
											var _opt = {};
											
											$.each(that.getGrid().grid("instance").p.colModel,function(i){
												if(this.name===col||i===col){
													_opt = this;
													return false;
												}
											})
											
											if(_os.length>0){
												_os.empty();
												var oSv = datas.value, key;												
					                            for (key in oSv) {
					                                if (oSv.hasOwnProperty(key) ){
					                                    ov = document.createElement("option");
					                                    ov.setAttribute("role","option");
					                                    ov.value = key; ov.innerHTML = oSv[key];	
					                                    if(_olv&&_olv==key) {ov.selected ="selected";}
					                                    _os.append($(ov));					                                  
					                                }
					                                
					                                
					                            }
					                            _opt._opt_temp_value = _opt.editoptions;
					                            _opt.editoptions = datas;
											}									
										},
										rowId:rowid
										},tcell.children().val());
							});
						}
						
						
					});
					
					that.getGrid().on('grid:beforerestorecell',function(e, rowid, data, option){
						var cfg = _cfg;
						if(cfg.edittype&&ngc.isFunction(cfg.afterChange)){
							$.each(that.getGrid().grid("instance").p.colModel,function(i){
								if(this._opt_temp_value){
									var _os = that._getCellObject(rowid,i).find('select');
									var oSv = this._opt_temp_value.value, key, _olv = that.getCell(this.name);												
		                            for (key in oSv) {
		                                if (oSv.hasOwnProperty(key) ){
		                                    ov = document.createElement("option");
		                                    ov.setAttribute("role","option");
		                                    ov.value = key; ov.innerHTML = oSv[key];	
		                                    if(_olv&&_olv==key) {ov.selected ="selected";}
		                                    _os.append($(ov));	
		                                   
		                                }
		                            }
		                            _opt.editoptions = _opt._opt_temp_value;								
								}
							})
						}
						
					});
					/*that.getGrid().on('grid:beforesaverow',function(e, rowid, data, option){
						
						 $.each(that.getGrid().grid("instance").p.colModel,function(i){
								if(this._opt_temp_value){
									this.editoptions = this._opt_temp_value;
								}
						})
					})*/
				
					
				}
				
				if(this.autocomplete=='autocomplete'){
					that.getGrid().on('grid:aftereditcell',function(e, rowid, colName, cellcontext, iRow, iCol){					
						var tcell = that._getCellObject(rowid,colName),cfg = _cfg;
						if(colName==cfg.name&&tcell.children()){							
							var _acfg = {
									minLength : cfg.minLength?cfg.minLength:2,
									source : ngc.isFunction(cfg.source)?cfg.source.bind(that):cfg.source,
									select: cfg.select?cfg.select:function (e, ui) {
										if(!cfg.dataValueField){
											$(this).val(ui.item);
											cfg.optionsIsArray = true;
										}else{
											$(this).val(ui.item[cfg.dataTextField]);
											cfg._realValue = ui.item[cfg.dataValueField||cfg.dataTextField];
										}
										
										return false;
									},
							        itemRenderer: cfg.itemRenderer?cfg.itemRenderer:function (item) {
							            return cfg.dataTextField?item[cfg.dataTextField]:item;
							        }
							}
							if(typeof(cfg._realValue)=='undefined'){
								cfg._realValue = tcell.children().val();
							}
							tcell.children().autocomplete(_acfg);	
							tcell.children().bind('input propertychange', function(e) {
								cfg._realValue = "";
							});
							
						}
						
						
					});
					that.getGrid().on('grid:aftereditrow',function(e, rowid, colName, cellcontext, iRow, iCol){					
						var tcell = that._getCellObject(rowid,_cfg.name),cfg = _cfg,colName = cfg.name;
						if(cfg.autocomplete=='autocomplete'&&tcell.children()){							
							var _acfg = {
									minLength : cfg.minLength?cfg.minLength:2,
									source : ngc.isFunction(cfg.source)?cfg.source.bind(that):cfg.source,
									select: cfg.select?cfg.select:function (e, ui) {
										if(!cfg.dataValueField){
											$(this).val(ui.item);
											cfg.optionsIsArray = true;
										}else{
											$(this).val(ui.item[cfg.dataTextField]);
											cfg._realValue = ui.item[cfg.dataValueField||cfg.dataTextField];
										}
										
										return false;
									},
							        itemRenderer: cfg.itemRenderer?cfg.itemRenderer:function (item) {
							            return cfg.dataTextField?item[cfg.dataTextField]:item;
							        }
							}
							if(typeof(cfg._realValue)=='undefined'){
								cfg._realValue = tcell.children().val();
							}
							tcell.children().autocomplete(_acfg);	
							tcell.children().bind('input propertychange', function(e) {
								cfg._realValue = "";
							});
							
						}
						
						
					});
					that.getGrid().grid("instance").p.colModel[k].unformat = function(text, options, cellval){
						if(_cfg.optionsIsArray){
							return cellval;
						}
						return _cfg._realValue?_cfg._realValue: $(cellval).text();
					}
				}
				
			});
		},
		
		_bindEnhanceFormatterTypeEvent:function(type,cfg){
			var that = this;
			if(type=='iconValue'){
				this.getGrid().on("grid:oncellselect",function(e, rowid, iCol, cellcontent){						
					if(cfg._colIndex==iCol&&$(cellcontent).attr("id")==cfg._formatter_ui_id&&$(cellcontent).css('display')!='none'){
						var _c_value = that.getCell(rowid,iCol);
						
						var _cur = 0, _index = 0 ,_length = 0, _map = {};
						$.each(cfg.match,function(key){
							if(key==_c_value){
								_cur = _index;
							}
							_map[_index] = key;
							_length++;	
							_index++;						
						});	
						
						var _cur_value = _map[(_cur+1)>(_length-1)?0:(_cur+1)];
						
						if(ngc.isFunction(cfg.beforeChange)){
							var _rst = cfg.beforeChange.call(that,rowid, iCol, _cur_value, _c_value, e, cellcontent);
							if(_rst===false){
								return false;
							}
						}
						that.setCell(rowid,iCol,_cur_value);
						
						if(ngc.isFunction(cfg.afterChange)){
							cfg.afterChange.call(that,rowid, iCol, _cur_value, _c_value, e, cellcontent);							
						}
					}
					
					
								
				});	
			}
		},
		
		_enhanceFormatterType:function(cfg){			
			var that = this;			
			var _id = ngc.getUUID();			
			if(cfg.formatter&&cfg.formatter=='iconValue'){
				cfg._formatter_ui_id = _id;
				cfg.formatter = function(cellval, opts, rwdat, _act){
					cfg._colIndex = opts.pos;
					var _cur = 0, _index = 0 ,_length = 0, _map = {}, _cv;
					$.each(cfg.match,function(key){
						if(_index==0)_cv = key;
						
						if(key==cellval){
							_cur = _index;
							_cv = key;
						}
						_map[_index] = this;
						_length++;	
						_index++;						
					});	
					var ind = that.getGridRowById(opts.rowId);
					if(cellval=='unused'){
						var tcell = $("td:eq(" + opts.pos + ")", ind);
						tcell.children().css('display','none');
						return tcell.children();
					}
					if(cellval=='used'){
						var tcell = $("td:eq(" + opts.pos + ")", ind);
						tcell.children().css('display','');
						return tcell.children();
					}
					
					var class_name = null;
					
					if(_map[_cur].indexOf("glyphicon")!=-1){
						class_name = 'glyphicon '+_map[_cur];
						return '<span aria-icon-value="'+_cv+'" class="'+class_name+'" id="'+opts.colModel._formatter_ui_id+'" aria-hidden="true"></span>';	
					}
					if(_map[_cur].indexOf("fa")!=-1){
						class_name = 'fa '+_map[_cur];
						return '<span aria-icon-value="'+_cv+'"  id="'+opts.colModel._formatter_ui_id+'" ><i class="'+class_name+'" aria-hidden="true"></i></span>';	
					}
					
					return '<span aria-icon-value="'+_cv+'" id="'+opts.colModel._formatter_ui_id+'" aria-hidden="true">'+_map[_cur]+'</span>';	
					
									 
				};
				cfg.unformat = function(text, options, cellval){
					if($(cellval).children().css('display')=='none'){
						return null;
					}
					return $(cellval).children().attr("aria-icon-value");
				}
				cfg.specUnformat = function(text, options, cellval){
					if($(cellval).children().css('display')=='none'){
						return null;
					}
					return text==='used'?$(cellval).children().attr("aria-icon-value"):text;
				}
			}
			return cfg;
		},
		
		//获取右键可用区域
		_getMenuClickObj:function(){
			return this.$(".slimScrollDiv");
		},
		
		/**
		 * 设置单元格内容隐藏
		 * @param {String} rowid 需要设置隐藏的单元格行id
		 * @param {String|Number} colname 需要设置隐藏的单元格列ID或者索引
		 */
		hideCell:function(rowid,colname){
			var tcell = this._getCellObject(rowid,colname);
			tcell.children().hide()
		},
		
		/**
		 * 获取单元格
		 * @method _getCellObject
		 * @param {String} rowid 需要设置隐藏的单元格行id
		 * @param {String|Number} colname 需要设置隐藏的单元格列ID或者索引
		 * @return {Object} 单元格内容的Jquery Object对象
		 */
		_getCellObject:function(rowid,colname){
			var ind = this.getGridRowById(rowid),pos = this.getColumnIndexByName(colname);			
			var tcell = $("td:eq(" + pos + ")", ind);
			return tcell;
		},
		
		
		/**
		 * 根据列名获取列索引号
		 * @param {String} colname 单元格列ID
		 * @return {Number} 单元格列索引
		 */
		getColumnIndexByName:function(colname){
			var pos = -1;
			if (isNaN(colname)) {
                $(this.getOptionConfig().grid.colModel).each(function(i) {
                    if (this.name === colname) { //hidden属性需要考虑嘛?
                        pos = i;
                        return false;
                    }
                });
            } else {
                pos = parseInt(colname, 10);
            }
			return pos;
		},
		
		/**
		 * 根据索引号获取列名
		 * @param {Number} colIndex 单元格列索引
		 * @return {String}  单元格列ID
		 */
		getColumnNameByIndex:function(colIndex){
			var colName = null;
			
			$(this.getOptionConfig().grid.colModel).each(function(i) {
                if (i === colIndex) { 
                	colName = this.name;
                    return false;
                }
            });
			return colName;
		},
		
		
		/**
		 * 设置单元格内容隐藏
		 * @param {String} rowid 需要设置隐藏的单元格行id
		 * @param {String|Number} colname 需要设置隐藏的单元格列ID或者索引
		 */
		showCell:function(rowid,colname){
			var tcell = this._getCellObject(rowid,colname);
			tcell.children().show();
		},
		
		
		/**
		 * @private 
		 * @method 右键菜单支持，增加事件处理
		 */
		onMenuEvent:function(id,menu,param){
			this.trigger('onClickMenu',id,this.getSelectRowId(),param,menu);
			
		}
		
        /**
         * 是否使用条纹状表格
         * @cfg {Boolean} altRows=false
         */

        /**
         * 表格最小高度
         * @cfg {Object} minHeight='150'
         */

        /**
         * 表格高度,默认取父容器的高度,可以设置具体数值
         * @cfg {Object} height
         *  <pre>
         *      1.未设置height：先取元素自身高度；
         *                      元素自身未设置高度，取其父元素的高度；
         *                      得到的高度如果为0或者小于150，则高度设置为150。
         *      2.height为auto：根据表格内容自动调节高度。
         *      3.height为100%：取离表格最近且有定义高度的parent元素的高度。
         *      4.height为具体值：则以该值作为表格高度。
         *      注意点:
         *      如果页面表格控件已经初始化计算出宽度,此时动态操作dom使页面出现垂直滚动条(垂直滚动条的出现会使屏幕变窄),此时宽度需要重新设置
         *  </pre>
         */

        /**
         * 分页对象,设置为true会根据grid创建出来,默认在grid底部构造id为gridid+pager的分页栏;
         * 也可以指定一个外部的selector,selector自行生成分页组件
         * @cfg {Boolean} pager
         */

        /**
         * 当前显示的是第几页.初始化的时候基本是第一页,一般用于取值
         * @cfg {Number} page=1
         */

        /**
         * 初始化一页显示的记录条数,默认无限大;
         * 分页的场景下，默认20条每页.
         * @cfg {Number} rowNum=20
         */

        /**
         * 初始化页码可选数量，默认显示10个页码按钮.
         * @cfg {Number} displayNum=10
         */

        /**
         * 记录总数.一般用于取值
         * @cfg {Number} records=0
         */

        /**
         * 当前页的记录总数.一般用于取值,最后一页的记录数往往跟rowNum不一样
         * @cfg {Number} reccount
         */

        /**
         * 是否显示分页前后所有可点击按钮
         * @cfg {Boolean} pgbuttons=true
         */

        /**
         * 是否显示分页的页码按钮
         * @cfg {Boolean} pgnumbers=true
         */

        /**
         * 是否显示分页的文本输入框，按回车可以跳转到指定的页
         * @cfg {Boolean} pginput=true
         */

        /**
         * 分页输入框的默认格式,默认取值为grid的国际化资源文件
         * @cfg {String} pgtext="Page {0} of {1}"
         */

        /**
         * 有分页栏的情况下显示详细的记录数，tree的场景下此参数无效
         * @cfg {Boolean} viewrecords=true
         */

        /**
         * 有分页栏的情况下显示分页总数，tree的场景下此参数无效
         * @cfg {Boolean} viewtotal=true
         */

        /**
         * 分页栏详细记录的语言提示,默认取值为grid的国际化资源文件
         * @cfg {String} recordtext="View {0} - {1} of {2}"
         */

        /**
         * 表格没有记录时表格主体所展示的提示语
         * @cfg {String} emptyrecords="No records to view"
         */

        /**
         * 分页的场景下,每页显示条数可选数据集,如[20,50,100]. 默认值为空数组，不提供选择
         * @cfg {Array} rowList=[]
         */

        /**
         * 分页情况下的总页数，一般用于取值
         * @cfg {Number} lastpage=0
         */

        /**
         * 排序方式，默认升序
         * @cfg {String} sortorder="asc"
         */

        /**
         * 排序的列标识
         * @cfg {String} sortname
         */

        /**
         * 表格是否支持多列排序，默认false
         * @cfg {Boolean} multiSort
         */

        /**
         * 记录上一次排序列的索引，一般用于取值，从0开始
         * @cfg {Number} lastsort
         */

        /**
         * 表格的分页类型，可设置为local/json
         * json 服务端分页，分页信息来自服务端返回的json数据，需要设置pageData参数，
         * local 本地分页，无需设置pageData参数。
         * @cfg {String} datatype="local"
         */

        /**
         * 服务器端数据接口函数，参数datatype为json时生效;此函数的返回值为包含分页信息的json数据，用户可以在此方法里面跟服务器作交互,此方法提供参数有目标页码，一页显示的记录个数，排序列及排序方式,这些参数有可以通过grid的方法获取到。
         * 如果pageData内函数是异步方式，可以直接返回false,等数据回调成功时reloadData即可
         * @cfg {Function} pageData
         */

        /**
         * json格式数据的定义
         * @cfg {Object} jsonReader={root: "rows",page: "page",total: "total",records: "records",id: "_id_",userdata: "userdata"}
         * @cfg {String} jsonReader.root=rows json格式中数据源对应的key值
         * @cfg {String} jsonReader.page=page json格式中当前页对应的key值
         * @cfg {String} jsonReader.total=total json格式中总页数对应的key值,treeGrid场景中,子节点无法计算,total必须要自己传进来
         * @cfg {String} jsonReader.records=records json格式中总记录数的key值,正常数据传入了总记录数,total就不需要传了,会自动计算出来的
         * @cfg {String} jsonReader.userdata=userdata json格式中额外数据的key值,可用于数据统计之类的
         */

        /**
         * 列的定义
         * @cfg {Object} colModel
         * @cfg {String} colModel.name     设置列在表格中的唯一名称，此属性是必须的。保留字rn,cb
         * @cfg {String} colModel.label    定义此列的标题,若为空，则标题为该列的name属性值
         * @cfg {Boolean} colModel.key=false    该列可设置为行ID,只有一列可设置该属性。
         * @cfg {Boolean} colModel.sortable=true  定义是否可以排序
         * @cfg {String} colModel.sorttype=text   用于定义排序列类型。可取int/integer、float/number/currency、date、text;也可以定义自定义函数
         * @cfg {Boolean} colModel.resizable=true  定义是否可变列宽
         * @cfg {Boolean} colModel.title=true     当设置为false时，鼠标滑向单元格时不显示title属性
         * @cfg {String} colModel.headertitle     鼠标划向列头时的提示,默认为列名
         * @cfg {Number} colModel.width=150       设置列的初始宽度，可用pixels和百分比
         * @cfg {String} colModel.align=left      定义表格单元格（非表头）的对齐方式，可取值：left, center, right
         * @cfg {Boolean} colModel.variablerowheight=false 不推荐使用，请使用wordwrap来控制. 用于定义表格单元格（非表头）文字是否折行显示，默认值为false，表示不折行显示
         * @cfg {Boolean} colModel.headerwordwrap=false 定义表格列头是否折行;默认值为false,表示不折行
         * @cfg {Boolean} colModel.wordwrap=false   定义表格列内容是否折行;默认值为false,表示不折行
         * @cfg {Boolean} colModel.hidden=false   定义初始化时，列是否隐藏
         * @cfg {Boolean} colModel.hidedlg=false  用户可以此控制列的显示或隐藏;若设置为true，该列将不能隐藏，即选择哪些列可以隐藏的场景下，此列不出现在选项里面
         * @cfg {String} colModel.classes         此属性用于定义列样式的类名，当有多个类名时，用空格间隔，例如：“class1 class2”。在表格的CSS中，有一个预定义的类ui-ellipsis用于定义特定的行
         * @cfg {Boolean} colModel.editable=false 定义字段是否可编辑，用于单元格编辑、行编辑
         * @cfg {String}  colModel.formatter      定义单元格的显示值，数据集内值与显示值可能不一样，可以是select、checkbox、integer、number、currency、date、linkFunction、actions(内置编辑删除功能);也可以扩展$.fn.fmatter自定义格式
         *                                        也可以指定一个function,返回一个html元素即可，function的参数为cellval(单元格值), opts(参数含rowid、列属性等), rwdat(行数据), _act(行为,是add还是edit方式调用的)
         * @cfg {Object} colModel.formatoptions     formatter格式的各种选项<br>
         * defaultValue : 数据集内值为空的时候默认显示这个值<br>
         * <b>integer类型：</b>
         * <pre>
         * thousandsSeparator： //千分位分隔符,
         * </pre>
         * <b>number类型：</b>
         * <pre>
         * decimalSeparator, //小数分隔符，如”.”
         * thousandsSeparator, //千分位分隔符，如”,”
         * decimalPlaces, //小数保留位数
         * </pre>
         * <b>currency类型：</b>
         * <pre>
         * transform, //是否对数据进行转换，为true时，先将数据除以pow(10, decimalPlaces)转换为小数，再格式化
         * decimalSeparator, //小数分隔符，如”.”
         * thousandsSeparator, //千分位分隔符，如”,”
         * decimalPlaces, //小数保留位数
         * prefix //前缀，如加上”$”
         * suffix//后缀
         * </pre>
         * <b>date类型：</b><br>
         * <b>checkbox类型：</b><br>
         * 没有参数时使用editoptions
         * <pre>
         * disabled //true/false 默认为true此时的checkbox不能编辑
         * value  为冒号分开的字符串,冒号前的是真值,会打勾
         * </pre>
         * <b>select类型：</b><br>
         * 设置下拉框，没有参数时使用editoptions<br>
         * value 可以是一个键值对对象;也可以是用冒号分号分割的字符串，数据集中的是key，界面将显示value值
         * <pre>
         * multiple 默认false,如果设置成true支持多选，多选的值界面上显示会用逗号隔开
         * delimiter 是value值为字符串的场景下，选项值的分割符，就是默认的分号
         * separator 是value值为字符串的场景下，每个选项的key:value分割符，就是默认的冒号
         * </pre>
         * <b>linkFunction类型：</b>
         * <pre>
         * cssp 样式，可以是classes，也可以是css对象
         * action 点击触发的事件,参数是rowid
         * </pre>
         * <b>actions类型：</b>
         * <pre>
         * editbutton=true 开启修改，保存，取消的功能;  扩展支持函数处理返回true/false
         * </pre>
         * 示例: `editbutton: function(rowData) { return true; }`
         * <pre>
         * delbutton=true 开启删除的功能;  扩展支持函数处理返回true/false
         * </pre>
         * 示例: `delbutton: function(rowData) { return true; }`
         * <pre>
         * inlineButtonAdd 开启自定义按钮， 扩展支持函数处理，每个对象代表一个按钮,{id,title,className,hide,icon},用户可以稍后自行通过jquery方式绑定事件
         * </pre>
         * 示例:
         * <pre>
         * inlineButtonAdd: function(rowData) {
         *     return [{id: "jLockButton", className: "inline-lock", icon: "glyphicon glyphicon-lock", title: "锁定"}];
         * }
         * </pre>
         * @cfg {String}  colModel.edittype=text   定义行编辑和表单模式的编辑类型，可以是text、textarea、select、checkbox、 password、button。
         * @cfg {Object}  colModel.editoptions     根据edittype 参数定义可用的值数组，其中checkbox,select参数值与formatoptions一致;其他的皆是文本框形式;含有defaultValue,在行编辑模式新增行数据且设置useDefValues=true的时候会默认使用这个值
         * @cfg {String}  colModel.editrules       设置可编辑字段的校验规则，规则详见校验控件
         * @cfg {Function} colModel.cellattr 在创建单元格内容的时候给单元格添加附加到属性
         * <pre>
         * cellattr: function(rowId, value, rowObject, colModel) {return ' colspan=2';}
         * 传递进入这个配置方法的参数如下
         * rowId - 单元格所属行id
         * value - 显示在单元格中的值
         * rawObject - 原始的数据行对象
         * colModel - 该列的属性
         * </pre>
         */

        /**
         * 定义列头是否隐藏不可见
         * @cfg {Boolean} colHide
         */
        /**
         * 单选条件下的选中的记录.一般用于取值
         * @cfg {String} selrow
         */

        /**
         * 复选条件下的选中的记录.一般用于获取打勾的记录
         * @cfg {Array} selarrrow
         */

        /**
         * 单元格编辑保存的内容.一般被用于保存记录时使用
         * @cfg {Array} savedRow
         */

        /**
         * 表头显示的标题
         * @cfg {String} caption
         */

        /**
         * 当含有表头时或者searchbar参数为true，是否出现表格缩放按钮
         * @cfg {Boolean} hidegrid=false
         */

        /**
         * 初始化是否隐藏表格
         * @cfg {Boolean} hiddengrid=false
         */

        /**
         * 表格数据额外的值，也可以存在于json格式数据中，可用于toolbar或者footerrow
         * @cfg {Object} userData
         */

        /**
         * 表格列宽是否按比例缩放，默认true
         * @cfg {Boolean} shrinkToFit=true
         */

        /**
         * 不推荐使用，表格宽度是否自适应，取决于父节点宽度，默认为false，否则可以设置width来指定表格宽度
         * @cfg {Boolean} autowidth=false
         */

        /**
         * 表格宽度是否自适应，取决于父节点宽度，同autowidth=true场景，否则可以设置width来指定表格宽度
         * @cfg {Boolean} width="100%"
         * <pre>
         *     1.未设置width，默认是100%：以父元素的宽度作为表格宽度。
         *     2.width为auto：根据表格内容自动调节宽度。
         *     3.width为具体指：以该值作为表格宽度。
         * </pre>
         */

        /**
         * 鼠标拖动修改某列宽度的时候其他列是否自适应填充
         * @cfg {Boolean} forceFit=false
         */

        /**
         * 表格状态，一般用于取值，判断表格是否隐藏
         * @cfg {String} gridstate="visible"
         */

        /**
         * 是否开启序号列,会产生一个name='rn'的colMod对象
         * @cfg {Boolean} rownumbers=false
         */

        /**
         * rownumbers序号列开启时的列宽
         * @cfg {Number} rownumWidth=25
         */

        /**
         * 开启表格多选功能,会产生一个name='cb'的colMod对象
         * @cfg {Boolean} multiselect=false
         */

        /**
         * 多选框列开启时的列宽
         * @cfg {Number} multiselectWidth=20
         */

        /**
         * 水平滚动条的高度,如果有样式修改了浏览器水平滚动条默认的高度,则这里需要同步修改
         * @cfg {Number} scrollOffset=18
         * @deprecated
         */

        /**
         * 是否在表格底部新增一行
         * @cfg {Boolean} footerrow=false
         */

        /**
         * 是否将userdata数据自动同步到footerrow那一行上,一般结合userData与footerrow参数用于统计
         * @cfg {Boolean} userDataOnFooter=false
         */

        /**
         * 是否开启单元格编辑模式，如果点击到可编辑的单元格时,不触发行选中事件
         * @cfg {Boolean} cellEdit=false
         */

        /**
         * 单元格编辑，切换单元格后，原值是否保存，默认true,可选"",false分别表示切换时不处理和不保存值
         * @cfg {Boolean} cellAutoSave=true
         */

        /**
         * 是否在表格上下新增两个空行,其中第一个参数为boolean,设置为true表示开启toolbar功能,第二个参数为'top'或者'bottom',分别表示是在表格上部还是下部新增空行.也可以设置成'both',上下都新增,新增的空行id默认为't_'或者'tb_'加上表格id,一般用户存放操作按钮或者显示额外信息
         * @cfg {Array} toolbar=[false, ""]
         */

        /**
         * 当设置某条记录选中时，如果此记录未在可见范围，滚动条会自动滚动，默认值true
         * @cfg {Boolean} scrollrows=true
         */

        /**
         * 是否开启快速加载模式，如果定义了afterInsertRow事件，此参数则要求设置为false
         * @cfg {Boolean} gridview=true
         */

        /**
         * 隐藏列的时候是否改变表格外层宽度
         * @cfg {Boolean} fixWidth=false
         */

        /**
         * 加载表格数据的时候是否出现loading遮罩,依赖blockui控件;此属性开启会采用延迟加载数据的方式,因此加载完数据对数据进行操作的步骤,需要放到数据加载完成事件(gridComplete)里完成;异步的场景就直接用fish.ajax,这里的参数就不要用了
         * @cfg {Boolean} showMask=false
         */

        /**
         * 表格列的通用属性,可简化colMod列的配置
         * @cfg {Object} cmTemplate
         */

        /**
         * 表格的数据源
         * @cfg {Array} data
         */

        /**
         * 表格是否启用tree形式
         * @cfg {Boolean} treeGrid
         */

        /**
         * tree格式的定义
         * @cfg {Object} treeReader={level: "level",parentid: "parent",leaf: "isLeaf",expanded: "expanded",icon: "icon"}
         * @cfg {String} treeReader.level=level 节点所在等级的key值
         * @cfg {String} treeReader.parentid=parent 节点的父节点的key值
         * @cfg {String} treeReader.leaf=isLeaf 是否为叶子节点的key值
         * @cfg {String} treeReader.expanded=expanded 节点是否展开的key值
         * @cfg {String} treeReader.icon=icon   节点显示图标的key值
         */

        /**
         * tree格式用来展开的那一列
         * @cfg {String} expandColumn
         */

        /**
         * 点击可展开列内容而不需要点击图标就支持节点缩放
         * @cfg {String} expandColClick=false
         */

        /**
         * treeGrid场景下节点的图标,一般分为展开,收缩,叶子节点三种,如果数据中含有icon属性,则取数据中的图标样式
         * @cfg {Boolean} treeIcons={plus: 'glyphicon glyphicon-triangle-right',minus:'glyphicon glyphicon-triangle-bottom',leaf:'glyphicon glyphicon-file',folderOpen:'glyphicon glyphicon-folder-open',folderClosed:'glyphicon glyphicon-folder-close'}
         */

        /**
         * @cfg {Function} treeIconFunction = $.noop
         * treeGrid场景下自定义节点图标的处理函数，参数为当前行的行数据，返回一个包含图标信息的对象
         * 如果设置了此参数，则这个参数得到的返回值将替代treeIcons参数值
         *
         * 示例：
         * <pre>
         * treeIconFunction : function (rowdata) {
         *   if (rowData.isLeaf) {
         *     return { leaf: 'glyphicon glyphicon-user' };
         *   } else if (rowData.isFolder) {
         *     return { folderOpen: 'glyphicon glyphicon-leaf', folderClosed: 'glyphicon glyphicon-leaf' };
         *   }
         * }
         * </pre>
         */

        /**
         * treeGrid场景下，节点类型是否支持转变，点击的节点如果没有子节点，则此节点的图标会变成叶子节点
         * @cfg {Boolean} leafChange=false
         * 注意：目前删光子节点,父节点会变成叶子节点的;这里是不是需要参数控制下?
         */

        /**
         * treeGrid的多选场景下，点击某个节点，是否自动选中它的所有父节点
         * @cfg {Boolean} checkParent=false
         */
 
        /**
         * treeGrid的多选场景下，点击某个节点，是否自动选中它的所有子节点
         * @cfg {Boolean} checkChildren=false
         */

        /**
         * 为列指定一个调整宽度时候的显示风格class
         * @cfg {String} resizeclass
         */

        /**
         * 单元格是否对html自动编码,单元格内有特殊字符的时候需要控制,如存在'<','>'等
         * @cfg {Boolean} autoencode=false
         */

        /**
         * 在窗口发生变化的时候，宽度能否根据父层容器的大小自适应
         * @cfg {Boolean} autoResizable=true
         */

        /**
         * @cfg {Boolean} [showColumnsFeature=false] 是否展示列功能
         */

        /**
         * @cfg {Boolean} [pagebar=false] 是否出现分页栏,pager和showColumnsFeature设置为true的时候自动会出现;也可以显式设置为true供navButton使用
         */

        /**
         * @cfg {Boolean} [cached=false] 列信息是否缓存到本地，默认是false
         */
        /**
         * @cfg {Boolean} [exportFeature=false] 是否显示导出按钮;可以是对象或者函数,为true表示导出当前页数据
         */


        /**
         * @cfg {Boolean} [subGrid=false] 是否含有子Grid
         */

        /**

         * @cfg {Number} [subGridWidth=20] 子Grid点击按钮默认宽度20px
         */

        /**

         * @cfg {Array} SubGrid模型，如果模型一致则使用该选项
         */

        /**

         * @cfg {Object} subGridAjaxOptions 通用模型下Ajax请求参数
         * @cfg {String | Function} subGridAjaxOptions.url 请求地址;或函数返回url
         * @cfg {String} subGridAjaxOptions.type 请求类型，默认post
         * @cfg {String} subGridAjaxOptions.data 请求其他参数，默认null
         * @cfg {String} subGridAjaxOptions.showMask，是否显示遮罩，默认false
         */

        /**
         * @event subGridBeforeExpand SubGrid 展开前事件，return false可组织SubGrid展开
         */

        /**
         * @event subGridRowExpanded SubGrid展开事件
         * @param  {Event} e 事件对象
         * @param  {String} subGridId  展开子表格的id
         * @param  {String}  parentRowId  用来展开子表格的行的rowId
         */

        /**
         * @event subGridRowColapsed  SubGrid收起事件
         */
        
        /**

         * @cfg {Object} subGridOptions SubGrid配置参数
         * @cfg {String} subGridOptions.plusIcon=glyphicon glyphicon-plus 收缩时图标
         * @cfg {String} subGridOptions.minusIcon=glyphicon glyphicon-minus 展开时图标
         * @cfg {Boolean} subGridOptions.reloadOnExpand=true, 展开时重新渲染SubGrid
         * @cfg {Boolean} subGridOptions.selectOnExpand=true, 展开时选中当前行
         * @cfg {Boolean} subGridOptions.selectOnCollapse=true, 收起时选中当前行
         */
        
        /**

         * @cfg {Boolean} grouping=false 表格是否启用分组功能
         */

        /**

         * @cfg {Object} groupingView 分组配置参数
         * @cfg {Array} groupingView.groupField=[] 分组列，如["colName"]。多个分组列，如["colName1", "colName2"]
         * @cfg {Array} groupingView.groupOrder=[] 分组列的排序方式，默认["asc"]。多个分组列，如["asc", "desc"]
         * @cfg {Array} groupingView.groupText=[]  分组结果展示文本,使用参数{0}传递分组结果，默认["<b>{0}</b>"]。多个分组列，如["<b>{0}</b>", "<i>{0}</i>"]
         * @cfg {Array} groupingView.groupColumnShow=[] 是否展示分组列，默认[true]。多个分组列，如[true, true]
         * @cfg {Array} groupingView.groupSummary=[] 是否启用分组求和功能 默认[false]。多个分组列，如[false, false]
         * @cfg {Boolean} groupingView.showSummaryOnHide=false 分组求和结果是否在分组收缩的时候展示，默认不展示
         * @cfg {Boolean} groupingView.groupCollapse=false 初始化分组是否收缩，默认是分组展开
         * @cfg {Boolean} groupingView.groupIndent=false 分组后的行是否缩进
         * @cfg {String} groupingView.plusicon='glyphicon glyphicon-triangle-right' 展开图标
         * @cfg {String} groupingView.minusicon='glyphicon glyphicon-triangle-bottom' 收缩图标
         * @cfg {Array} groupingView.displayField=[] 分组展示哪一列的值，默认为分组列的值
         * @cfg {Array} groupingView.groupSummaryPos=[] 求和结果展示的位置，默认["footer"]。多个分组列，如["header", "header"]
         * @cfg {Boolean} groupingView._locgr=false 默认为false，请勿修改该参数值
         *
         * 例如：
         * <pre>
         *       groupingView: {
         *           groupField: ["colName1", "colName2"],      //列名为colName1和colName2这两列作为分组列
         *           groupOrder：["asc", "desc"],               //colName1的排序方式为asc，colName2的排序方式为desc
         *           groupText: ["<b>{0}</b>", "<i>{0}</i>"],   //"&lt;b&gt;{0}&lt;/b&gt;", "&lt;i&gt;{0}&lt;/i&gt;"
         *           groupColumnShow: [true, true],
         *           groupSummary: [true, true],
         *           groupSummaryPos: ["header", "header"],
         *           groupCollapse: false                       //两个分组初始化之后展开
         *       }
         * </pre>
         */
        
        /**
         * @cfg {Object} editIcons 表格行内编辑场景下的图标
         * @cfg {String} editIcons.edit='glyphicon glyphicon-pencil' 编辑图标
         * @cfg {String} editIcons.delete='glyphicon glyphicon-remove-circle' 删除图标
         * @cfg {String} editIcons.save='glyphicon glyphicon-floppy-disk' 保存图标
         * @cfg {String} editIcons.cancel='glyphicon glyphicon-ban-circle' 取消图标
         */

        /**
         * @cfg {Boolean} curPageSort=false 在对含有分页的表格进行排序时，排序内容是否是当前页的数据；如果为true，则只对当前页的数据进行本地排序；如果为false，则对(数据来于远程服务/本地)表格的所有数据进行(远程服务/本地)排序；
         */

        /**
         * @cfg {Boolean} cellAutoRestore=true 
         * 当beforeSaveCell事件返回false时，是否取消当前单元格的修改。为true取消修改还原之前的值。为false不取消修改。默认为true
         */
		
		
		/**
         * @cfg {String} searchMode="position" 搜索模式
         * 含有searchbar的表格进行搜索时，参数值为"position"/"filter"。
         * 此参数为"position"，表示定位到第一个满足搜索条件的数据并选中，对表格数据不做筛选。
         * 为"filter"，表格按照搜索条件进行刷选，表格只保留满足搜索条件的数据，不做选中操作。
         */
		
		/**
         * @cfg {Boolean} searchbar=false
         * 是否出现搜索框
         */
		
		  /**
         * @cfg {Function} showSubgridBtn=$.noop
         * subgrid为true场景下是否展示子表格展开按钮的处理函数，以当前行的行数据为参数。函数结果返回true/false，则按钮展示/隐藏
         * 如果函数无返回结果则默认展示按钮
         *
         * 示例：
         * <pre>
         * showSubgridBtn : function (rowdata) {
         *   var ifShow = rowdata[children].length > 0 ? true : false;
         *   return ifShow;
         * }
         * </pre>
         */
		
		//~~~事件相关
		
		/**
		 * 编辑行之前的事件,可用于判断能不能编辑等,返回false中断操作
		 * @event beforeEditRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		/**
		 * 编辑行之后的事件,可用于表单的渲染,如渲染成时间控件等
		 * @event afterEditRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */

		/**
		 * 保存行之前的事件,可用于数据校验等,返回false中断操作
		 * @event beforeSaveRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		/**
		 * 保存行之后的事件,可用于同步界面其他变化等
		 * @event afterSaveRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */

		/**
		 * 取消行编辑之前的事件,返回false中断操作
		 * @event beforeRestoreRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		/**
		 * 取消行编辑之后的事件,可用于同步界面其他变化等
		 * @event afterRestoreRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */

		/**
		 * 删除行之前的事件,可用于判断能不能删除等,返回false中断操作
		 * @event beforeDeleteRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		/**
		 * 删除行之后的事件,可用于同步界面其他变化等
		 * @event afterDeleteRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */

		/**
		 * 新增行之前的事件,返回false中断操作
		 * @event beforeAddRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		/**
		 * 新增行之后的事件,实际上是新增了一条记录再进行编辑的,可用来补充编辑行为等
		 * @event afterAddRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {Object} data   行数据
		 * @param  {Object} option 参数对象,内置'oper'用来区分操作行为
		 */
		
		/**
		 * 表格事件操作完成的事件
		 * @event gridComplete
		 */
		/**
		 * 加载每一条数据触发的事件,可修改每一行的展示,需要设置参数gridview为false
		 * @event afterInsertRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @param  {Object} data 行数据对象
		 */
		/**
		 * 单击其他行之后的事件,与选中行事件的区别在于点击已选中的记录不再会触发事件
		 * @event onChangeRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 目标选中的行id
		 * @param  {String} oldrowid 之前选中的行id
		 */
		/**
		 * 单击选中行之后的事件
		 * @event onSelectRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @param  {Boolean} state 选中的是否是同一行
		 * @param  {Boolean} checked 多选场景下,选中行是否打勾
		 */
		/**
		 * 选中单元格的事件
		 * @event onCellSelect
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @param  {Number} iCol  列索引
		 * @param  {String} cellcontent 单元格内容
		 */
		/**
		 * 双击选中行事件
		 * @event onDblClickRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 右击选中行事件
		 * @event onRightClickRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 单击选中行开始的事件
		 * @event beforeSelectRow
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 * @return {Boolean} 返回值，返回false中断选中行操作
		 */
		/**
		 * 点击排序开始的事件
		 * @event onSortCol
		 * @param  {Event} e 事件对象
		 * @param  {String} sortname 排序列名称
		 * @param  {Number} iCol  列索引
		 * @param  {String} sortorder 排序方式,升序还是降序
		 * @return {String} 返回值，返回false中断排序操作
		 */
		/**
		 * 列头拖拽的开始事件
		 * @event resizeStart
		 * @param  {Event} e 事件对象
		 * @return {number} idx 列索引
		 */
		/**
		 * 列头拖拽的结束事件
		 * @event resizeStop
		 * @param  {Event} e 事件对象
		 * @param  {Number} nw  新的列宽
		 * @return {Number} idx 列索引
		 */
		/**
		 * 点击表头缩放按钮触发的事件
		 * @event onHeaderClick
		 * @param  {Event} e 事件对象
		 * @param  {String} gridstate  表格状态,visible或者hidden
		 */
		/**
		 * 按回车键触发事件
		 * @event onEnter
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 */
		/**
		 * 按空格键触发事件
		 * @event onSpace
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 */
		/**
		 * 按左移键触发事件;如果是tree则收缩节点
		 * @event onLeftKey
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 */
		/**
		 * 按右移键触发事件;如果是tree则展开节点
		 * @event onRightKey
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid 行id
		 */
		/**
		 * 重载表格数据的事件
		 * @event reloadGrid
		 * @param  {Event} e 事件对象
		 * @param  {Object} [opt] 重载参数,一般为{page:n}格式,表示加载的页数
		 */
		/**
		 * 点击分页按钮触发的事件
		 * @event onPaging
		 * @param  {Event} e 事件对象
		 * @param  {Number} page 分页的页码
		 * @param  {Object} opt 点击的按钮位置,对应first,prev,next,last;如果是直接输入页码,则此值为user
		 * @return {String} 返回值，返回false中断翻页操作
		 */
		/**
		 * 点击列头全选按钮触发的事件
		 * @event onSelectAll
		 * @param  {Event} e 事件对象
		 * @param  {Boolean} status 表格状态,true表示选中,false表示没有选中
		 */
		/**
		 * 点击列头全选按钮触发的事件
		 * @event showHideCol
		 * @param  {Event} e 事件对象
		 * @param  {Boolean} show  显示(true)还是隐藏(false),
		 * @param  {String}  name  操作的列名,隐藏多列的话,会触发多次
		 * @param  {Number}  index 操作的列索引
		 */
		/**
		 * 编辑单元格前绑定的事件
		 * @event beforeEditCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 编辑单元格后绑定的事件
		 * @event afterEditCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 保存单元格数据前绑定的事件,返回false则取消单元格的修改并中断保存操作
		 * @event beforeSaveCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 保存单元格数据后绑定的事件
		 * @event afterSaveCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 取消单元格编辑前绑定的事件,返回false中断操作
		 * @event beforeRestoreCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */
		/**
		 * 取消单元格编辑后绑定的事件
		 * @event afterRestoreCell
		 * @param  {Event} e 事件对象
		 * @param  {String} rowid  行id
		 * @param  {String} colName  列名
		 * @param  {String} cellcontext  单元格值
		 * @param  {Number} iRow  行索引
		 * @param  {Number} iCol  列索引
		 */


	});
	
	return GridView;

})